home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 March / PCWMAR09.iso / Software / Freeware / Adobe Media Player 1.6 / adobe_media_player.air / AMP.swf / scripts / mx / controls / ProgressBar.as < prev    next >
Encoding:
Text File  |  2008-11-25  |  28.8 KB  |  881 lines
  1. package mx.controls
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.Graphics;
  5.    import flash.events.Event;
  6.    import flash.events.IEventDispatcher;
  7.    import flash.events.ProgressEvent;
  8.    import flash.events.TimerEvent;
  9.    import flash.text.TextLineMetrics;
  10.    import flash.utils.Timer;
  11.    import mx.core.FlexVersion;
  12.    import mx.core.IFlexDisplayObject;
  13.    import mx.core.IFlexModuleFactory;
  14.    import mx.core.IFontContextComponent;
  15.    import mx.core.IUITextField;
  16.    import mx.core.UIComponent;
  17.    import mx.core.UITextField;
  18.    import mx.core.mx_internal;
  19.    import mx.styles.ISimpleStyleClient;
  20.    
  21.    use namespace mx_internal;
  22.    
  23.    public class ProgressBar extends UIComponent implements IFontContextComponent
  24.    {
  25.       mx_internal static const VERSION:String = "3.2.0.3958";
  26.       
  27.       private var _direction:String = "right";
  28.       
  29.       private var stopPolledMode:Boolean = false;
  30.       
  31.       mx_internal var _labelField:IUITextField;
  32.       
  33.       mx_internal var _determinateBar:IFlexDisplayObject;
  34.       
  35.       private var sourceChanged:Boolean = false;
  36.       
  37.       private var _interval:Number = 30;
  38.       
  39.       private var trackSkinChanged:Boolean = false;
  40.       
  41.       mx_internal var _content:UIComponent;
  42.       
  43.       private var _source:Object;
  44.       
  45.       mx_internal var _track:IFlexDisplayObject;
  46.       
  47.       mx_internal var _bar:UIComponent;
  48.       
  49.       mx_internal var _barMask:IFlexDisplayObject;
  50.       
  51.       private var barSkinChanged:Boolean = false;
  52.       
  53.       private var _stringSource:String;
  54.       
  55.       private var _labelPlacement:String = "bottom";
  56.       
  57.       private var _value:Number = 0;
  58.       
  59.       private var indeterminateChanged:Boolean = true;
  60.       
  61.       private var _mode:String = "event";
  62.       
  63.       private var stringSourceChanged:Boolean = false;
  64.       
  65.       private var modeChanged:Boolean = false;
  66.       
  67.       private var _conversion:Number = 1;
  68.       
  69.       mx_internal var _indeterminateBar:IFlexDisplayObject;
  70.       
  71.       private var indeterminateSkinChanged:Boolean = false;
  72.       
  73.       private var _indeterminate:Boolean = false;
  74.       
  75.       private var pollTimer:Timer;
  76.       
  77.       private var _minimum:Number = 0;
  78.       
  79.       private var labelOverride:String;
  80.       
  81.       private var _maximum:Number = 0;
  82.       
  83.       private var visibleChanged:Boolean = false;
  84.       
  85.       private var indeterminatePlaying:Boolean = false;
  86.       
  87.       private var _label:String;
  88.       
  89.       public function ProgressBar()
  90.       {
  91.          super();
  92.          pollTimer = new Timer(_interval);
  93.          cacheAsBitmap = true;
  94.       }
  95.       
  96.       [Bindable("minimumChanged")]
  97.       public function get minimum() : Number
  98.       {
  99.          return _minimum;
  100.       }
  101.       
  102.       [Bindable("conversionChanged")]
  103.       public function get conversion() : Number
  104.       {
  105.          return _conversion;
  106.       }
  107.       
  108.       private function completeHandler(param1:Event) : void
  109.       {
  110.          dispatchEvent(param1);
  111.          invalidateDisplayList();
  112.       }
  113.       
  114.       [Bindable("sourceChanged")]
  115.       public function get source() : Object
  116.       {
  117.          return _source;
  118.       }
  119.       
  120.       public function set minimum(param1:Number) : void
  121.       {
  122.          if(!isNaN(param1) && _mode == ProgressBarMode.MANUAL && param1 != _minimum)
  123.          {
  124.             _minimum = param1;
  125.             invalidateDisplayList();
  126.             dispatchEvent(new Event("minimumChanged"));
  127.          }
  128.       }
  129.       
  130.       [Bindable("maximumChanged")]
  131.       public function get maximum() : Number
  132.       {
  133.          return _maximum;
  134.       }
  135.       
  136.       override protected function createChildren() : void
  137.       {
  138.          var _loc1_:Class = null;
  139.          super.createChildren();
  140.          if(!mx_internal::_content)
  141.          {
  142.             mx_internal::_content = new UIComponent();
  143.             addChild(mx_internal::_content);
  144.          }
  145.          if(!mx_internal::_bar)
  146.          {
  147.             mx_internal::_bar = new UIComponent();
  148.             mx_internal::_content.addChild(mx_internal::_bar);
  149.          }
  150.          if(!mx_internal::_barMask)
  151.          {
  152.             if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  153.             {
  154.                _loc1_ = getStyle("maskSkin");
  155.                mx_internal::_barMask = new _loc1_();
  156.             }
  157.             else
  158.             {
  159.                mx_internal::_barMask = new UIComponent();
  160.             }
  161.             mx_internal::_barMask.visible = true;
  162.             mx_internal::_bar.addChild(DisplayObject(mx_internal::_barMask));
  163.             UIComponent(mx_internal::_bar).mask = DisplayObject(mx_internal::_barMask);
  164.          }
  165.          if(!mx_internal::_labelField)
  166.          {
  167.             mx_internal::_labelField = IUITextField(createInFontContext(UITextField));
  168.             mx_internal::_labelField.styleName = this;
  169.             addChild(DisplayObject(mx_internal::_labelField));
  170.          }
  171.       }
  172.       
  173.       public function set source(param1:Object) : void
  174.       {
  175.          var value:Object = param1;
  176.          if(value is String)
  177.          {
  178.             _stringSource = String(value);
  179.             try
  180.             {
  181.                value = document[_stringSource];
  182.             }
  183.             catch(e:Error)
  184.             {
  185.                stringSourceChanged = true;
  186.             }
  187.          }
  188.          if(Boolean(_source) && _source is IEventDispatcher)
  189.          {
  190.             removeSourceListeners();
  191.          }
  192.          if(value)
  193.          {
  194.             _source = value;
  195.             sourceChanged = true;
  196.             modeChanged = true;
  197.             indeterminateChanged = true;
  198.             invalidateProperties();
  199.             invalidateDisplayList();
  200.          }
  201.          else if(_source != null)
  202.          {
  203.             _source = null;
  204.             sourceChanged = true;
  205.             indeterminateChanged = true;
  206.             invalidateProperties();
  207.             invalidateDisplayList();
  208.             pollTimer.reset();
  209.          }
  210.       }
  211.       
  212.       public function set conversion(param1:Number) : void
  213.       {
  214.          if(!isNaN(param1) && Number(param1) > 0 && param1 != _conversion)
  215.          {
  216.             _conversion = Number(param1);
  217.             invalidateDisplayList();
  218.             dispatchEvent(new Event("conversionChanged"));
  219.          }
  220.       }
  221.       
  222.       public function set maximum(param1:Number) : void
  223.       {
  224.          if(!isNaN(param1) && _mode == ProgressBarMode.MANUAL && param1 != _maximum)
  225.          {
  226.             _maximum = param1;
  227.             invalidateDisplayList();
  228.             dispatchEvent(new Event("maximumChanged"));
  229.          }
  230.       }
  231.       
  232.       public function set mode(param1:String) : void
  233.       {
  234.          if(param1 != _mode)
  235.          {
  236.             if(_mode == ProgressBarMode.POLLED)
  237.             {
  238.                stopPolledMode = true;
  239.             }
  240.             _mode = param1;
  241.             modeChanged = true;
  242.             indeterminateChanged = true;
  243.             invalidateProperties();
  244.             invalidateDisplayList();
  245.          }
  246.       }
  247.       
  248.       private function removeSourceListeners() : void
  249.       {
  250.          _source.removeEventListener(ProgressEvent.PROGRESS,progressHandler);
  251.          _source.removeEventListener(Event.COMPLETE,completeHandler);
  252.       }
  253.       
  254.       private function stopPlayingIndeterminate() : void
  255.       {
  256.          if(indeterminatePlaying)
  257.          {
  258.             indeterminatePlaying = false;
  259.             pollTimer.removeEventListener(TimerEvent.TIMER,updateIndeterminateHandler);
  260.             if(_mode != ProgressBarMode.POLLED)
  261.             {
  262.                pollTimer.reset();
  263.             }
  264.          }
  265.       }
  266.       
  267.       [Bindable("labelPlacementChanged")]
  268.       public function get labelPlacement() : String
  269.       {
  270.          return _labelPlacement;
  271.       }
  272.       
  273.       private function progressHandler(param1:ProgressEvent) : void
  274.       {
  275.          _setProgress(param1.bytesLoaded,param1.bytesTotal);
  276.       }
  277.       
  278.       override protected function measure() : void
  279.       {
  280.          var _loc1_:Number = NaN;
  281.          var _loc2_:Number = NaN;
  282.          super.measure();
  283.          var _loc3_:Number = NaN;
  284.          var _loc4_:Number = NaN;
  285.          var _loc5_:Number = getStyle("trackHeight");
  286.          var _loc6_:Number = Number(mx_internal::_track.measuredWidth);
  287.          var _loc7_:Number = isNaN(_loc5_) ? Number(mx_internal::_track.measuredHeight) : _loc5_;
  288.          var _loc8_:Number = getStyle("horizontalGap");
  289.          var _loc9_:Number = getStyle("verticalGap");
  290.          var _loc10_:Number = getStyle("paddingLeft");
  291.          var _loc11_:Number = getStyle("paddingRight");
  292.          var _loc12_:Number = getStyle("paddingTop");
  293.          var _loc13_:Number = getStyle("paddingBottom");
  294.          var _loc14_:Number = getStyle("labelWidth");
  295.          var _loc15_:TextLineMetrics = measureText(predictLabelText());
  296.          var _loc16_:Number = isNaN(_loc14_) ? _loc15_.width + UITextField.mx_internal::TEXT_WIDTH_PADDING : _loc14_;
  297.          var _loc17_:Number = _loc15_.height + UITextField.mx_internal::TEXT_HEIGHT_PADDING;
  298.          switch(labelPlacement)
  299.          {
  300.             case ProgressBarLabelPlacement.LEFT:
  301.             case ProgressBarLabelPlacement.RIGHT:
  302.                _loc1_ = _loc16_ + _loc6_ + _loc10_ + _loc11_ + _loc8_;
  303.                _loc2_ = Math.max(_loc17_,_loc7_) + _loc12_ + _loc13_;
  304.                measuredMinWidth = _loc1_;
  305.                break;
  306.             case ProgressBarLabelPlacement.CENTER:
  307.                _loc1_ = Math.max(_loc16_,_loc6_) + _loc10_ + _loc11_ + _loc8_;
  308.                _loc2_ = Math.max(_loc17_,_loc7_) + _loc12_ + _loc13_;
  309.                measuredMinWidth = _loc16_;
  310.                break;
  311.             default:
  312.                _loc1_ = Math.max(_loc16_,_loc6_) + _loc10_ + _loc11_;
  313.                _loc2_ = _loc17_ + _loc7_ + _loc12_ + _loc13_ + _loc9_;
  314.                measuredMinWidth = _loc16_;
  315.          }
  316.          measuredWidth = _loc1_;
  317.          measuredMinHeight = measuredHeight = _loc2_;
  318.          if(!isNaN(_loc3_))
  319.          {
  320.             measuredMinWidth = _loc3_;
  321.          }
  322.          if(!isNaN(_loc4_))
  323.          {
  324.             measuredMinHeight = _loc4_;
  325.          }
  326.       }
  327.       
  328.       public function get fontContext() : IFlexModuleFactory
  329.       {
  330.          return moduleFactory;
  331.       }
  332.       
  333.       private function predictLabelText() : String
  334.       {
  335.          var _loc2_:Number = NaN;
  336.          if(label == null)
  337.          {
  338.             return "";
  339.          }
  340.          var _loc1_:String = label;
  341.          if(_maximum != 0)
  342.          {
  343.             _loc2_ = _maximum;
  344.          }
  345.          else
  346.          {
  347.             _loc2_ = 100000;
  348.          }
  349.          if(_loc1_)
  350.          {
  351.             if(_indeterminate)
  352.             {
  353.                _loc1_ = _loc1_.replace("%1",String(Math.floor(_loc2_ / _conversion)));
  354.                _loc1_ = _loc1_.replace("%2","??");
  355.                _loc1_ = _loc1_.replace("%3","");
  356.                _loc1_ = _loc1_.replace("%%","");
  357.             }
  358.             else
  359.             {
  360.                _loc1_ = _loc1_.replace("%1",String(Math.floor(_loc2_ / _conversion)));
  361.                _loc1_ = _loc1_.replace("%2",String(Math.floor(_loc2_ / _conversion)));
  362.                _loc1_ = _loc1_.replace("%3","100");
  363.                _loc1_ = _loc1_.replace("%%","%");
  364.             }
  365.          }
  366.          var _loc3_:String = getFullLabelText();
  367.          if(_loc1_.length > _loc3_.length)
  368.          {
  369.             return _loc1_;
  370.          }
  371.          return _loc3_;
  372.       }
  373.       
  374.       [Bindable("change")]
  375.       public function get value() : Number
  376.       {
  377.          return _value;
  378.       }
  379.       
  380.       public function set indeterminate(param1:Boolean) : void
  381.       {
  382.          _indeterminate = param1;
  383.          indeterminateChanged = true;
  384.          invalidateProperties();
  385.          invalidateDisplayList();
  386.          dispatchEvent(new Event("indeterminateChanged"));
  387.       }
  388.       
  389.       private function createBar() : void
  390.       {
  391.          if(mx_internal::_determinateBar)
  392.          {
  393.             mx_internal::_bar.removeChild(DisplayObject(mx_internal::_determinateBar));
  394.             mx_internal::_determinateBar = null;
  395.          }
  396.          var _loc1_:Class = getStyle("barSkin");
  397.          if(_loc1_)
  398.          {
  399.             mx_internal::_determinateBar = new _loc1_();
  400.             if(mx_internal::_determinateBar is ISimpleStyleClient)
  401.             {
  402.                ISimpleStyleClient(mx_internal::_determinateBar).styleName = this;
  403.             }
  404.             mx_internal::_bar.addChild(DisplayObject(mx_internal::_determinateBar));
  405.          }
  406.       }
  407.       
  408.       private function createIndeterminateBar() : void
  409.       {
  410.          if(mx_internal::_indeterminateBar)
  411.          {
  412.             mx_internal::_bar.removeChild(DisplayObject(mx_internal::_indeterminateBar));
  413.             mx_internal::_indeterminateBar = null;
  414.          }
  415.          var _loc1_:Class = getStyle("indeterminateSkin");
  416.          if(_loc1_)
  417.          {
  418.             mx_internal::_indeterminateBar = new _loc1_();
  419.             if(mx_internal::_indeterminateBar is ISimpleStyleClient)
  420.             {
  421.                ISimpleStyleClient(mx_internal::_indeterminateBar).styleName = this;
  422.             }
  423.             mx_internal::_indeterminateBar.visible = false;
  424.             mx_internal::_bar.addChild(DisplayObject(mx_internal::_indeterminateBar));
  425.          }
  426.       }
  427.       
  428.       [Bindable("directionChanged")]
  429.       public function get direction() : String
  430.       {
  431.          return _direction;
  432.       }
  433.       
  434.       private function addSourceListeners() : void
  435.       {
  436.          _source.addEventListener(ProgressEvent.PROGRESS,progressHandler);
  437.          _source.addEventListener(Event.COMPLETE,completeHandler);
  438.       }
  439.       
  440.       private function updateIndeterminateHandler(param1:Event) : void
  441.       {
  442.          if(mx_internal::_indeterminateBar.x < 1)
  443.          {
  444.             mx_internal::_indeterminateBar.x += 1;
  445.          }
  446.          else
  447.          {
  448.             mx_internal::_indeterminateBar.x = -(getStyle("indeterminateMoveInterval") - 2);
  449.          }
  450.       }
  451.       
  452.       private function updatePolledHandler(param1:Event) : void
  453.       {
  454.          var _loc2_:Object = null;
  455.          var _loc3_:Number = NaN;
  456.          var _loc4_:Number = NaN;
  457.          if(_source)
  458.          {
  459.             _loc2_ = _source;
  460.             _loc3_ = Number(_loc2_.bytesLoaded);
  461.             _loc4_ = Number(_loc2_.bytesTotal);
  462.             if(!isNaN(_loc3_) && !isNaN(_loc4_))
  463.             {
  464.                _setProgress(_loc3_,_loc4_);
  465.                if(percentComplete >= 100 && _value > 0)
  466.                {
  467.                   pollTimer.reset();
  468.                }
  469.             }
  470.          }
  471.       }
  472.       
  473.       public function set labelPlacement(param1:String) : void
  474.       {
  475.          if(param1 != _labelPlacement)
  476.          {
  477.             _labelPlacement = param1;
  478.          }
  479.          invalidateSize();
  480.          invalidateDisplayList();
  481.          dispatchEvent(new Event("labelPlacementChanged"));
  482.       }
  483.       
  484.       [Bindable("modeChanged")]
  485.       public function get mode() : String
  486.       {
  487.          return _mode;
  488.       }
  489.       
  490.       [Bindable("progress")]
  491.       public function get percentComplete() : Number
  492.       {
  493.          if(_value < _minimum || _maximum < _minimum)
  494.          {
  495.             return 0;
  496.          }
  497.          if(_maximum - _minimum == 0)
  498.          {
  499.             return 0;
  500.          }
  501.          var _loc1_:Number = 100 * (_value - _minimum) / (_maximum - _minimum);
  502.          if(isNaN(_loc1_) || _loc1_ < 0)
  503.          {
  504.             return 0;
  505.          }
  506.          if(_loc1_ > 100)
  507.          {
  508.             return 100;
  509.          }
  510.          return _loc1_;
  511.       }
  512.       
  513.       public function setProgress(param1:Number, param2:Number) : void
  514.       {
  515.          if(_mode == ProgressBarMode.MANUAL)
  516.          {
  517.             _setProgress(param1,param2);
  518.          }
  519.       }
  520.       
  521.       private function createTrack() : void
  522.       {
  523.          if(mx_internal::_track)
  524.          {
  525.             mx_internal::_content.removeChild(DisplayObject(mx_internal::_track));
  526.             mx_internal::_track = null;
  527.          }
  528.          var _loc1_:Class = getStyle("trackSkin");
  529.          if(_loc1_)
  530.          {
  531.             mx_internal::_track = new _loc1_();
  532.             if(mx_internal::_track is ISimpleStyleClient)
  533.             {
  534.                ISimpleStyleClient(mx_internal::_track).styleName = this;
  535.             }
  536.             mx_internal::_content.addChildAt(DisplayObject(mx_internal::_track),0);
  537.          }
  538.       }
  539.       
  540.       [Bindable("indeterminateChanged")]
  541.       public function get indeterminate() : Boolean
  542.       {
  543.          return _indeterminate;
  544.       }
  545.       
  546.       private function startPlayingIndeterminate() : void
  547.       {
  548.          if(!indeterminatePlaying)
  549.          {
  550.             indeterminatePlaying = true;
  551.             pollTimer.addEventListener(TimerEvent.TIMER,updateIndeterminateHandler,false,0,true);
  552.             pollTimer.start();
  553.          }
  554.       }
  555.       
  556.       override public function styleChanged(param1:String) : void
  557.       {
  558.          var _loc2_:Boolean = false;
  559.          super.styleChanged(param1);
  560.          if(param1 == null || param1 == "styleName")
  561.          {
  562.             barSkinChanged = trackSkinChanged = indeterminateSkinChanged = true;
  563.             _loc2_ = true;
  564.          }
  565.          else if(param1 == "barSkin")
  566.          {
  567.             barSkinChanged = true;
  568.             _loc2_ = true;
  569.          }
  570.          else if(param1 == "trackSkin")
  571.          {
  572.             trackSkinChanged = true;
  573.             _loc2_ = true;
  574.          }
  575.          else if(param1 == "indeterminateSkin")
  576.          {
  577.             indeterminateSkinChanged = true;
  578.             _loc2_ = true;
  579.          }
  580.          if(_loc2_)
  581.          {
  582.             invalidateProperties();
  583.             invalidateSize();
  584.             invalidateDisplayList();
  585.          }
  586.       }
  587.       
  588.       private function getFullLabelText() : String
  589.       {
  590.          var _loc1_:Number = Math.max(_value,0);
  591.          var _loc2_:Number = Math.max(_maximum,0);
  592.          var _loc3_:String = label;
  593.          if(_loc3_)
  594.          {
  595.             if(_indeterminate)
  596.             {
  597.                _loc3_ = _loc3_.replace("%1",String(Math.floor(_loc1_ / _conversion)));
  598.                _loc3_ = _loc3_.replace("%2","??");
  599.                _loc3_ = _loc3_.replace("%3","");
  600.                _loc3_ = _loc3_.replace("%%","");
  601.             }
  602.             else
  603.             {
  604.                _loc3_ = _loc3_.replace("%1",String(Math.floor(_loc1_ / _conversion)));
  605.                _loc3_ = _loc3_.replace("%2",String(Math.floor(_loc2_ / _conversion)));
  606.                _loc3_ = _loc3_.replace("%3",String(Math.floor(percentComplete)));
  607.                _loc3_ = _loc3_.replace("%%","%");
  608.             }
  609.          }
  610.          return _loc3_;
  611.       }
  612.       
  613.       override protected function commitProperties() : void
  614.       {
  615.          var index:int = 0;
  616.          super.commitProperties();
  617.          if(hasFontContextChanged() && mx_internal::_labelField != null)
  618.          {
  619.             index = getChildIndex(DisplayObject(mx_internal::_labelField));
  620.             removeChild(DisplayObject(mx_internal::_labelField));
  621.             mx_internal::_labelField = IUITextField(createInFontContext(UITextField));
  622.             mx_internal::_labelField.styleName = this;
  623.             addChildAt(DisplayObject(mx_internal::_labelField),index);
  624.          }
  625.          if(trackSkinChanged)
  626.          {
  627.             trackSkinChanged = false;
  628.             createTrack();
  629.          }
  630.          if(barSkinChanged)
  631.          {
  632.             barSkinChanged = false;
  633.             createBar();
  634.          }
  635.          if(indeterminateSkinChanged)
  636.          {
  637.             indeterminateSkinChanged = false;
  638.             createIndeterminateBar();
  639.          }
  640.          if(stringSourceChanged)
  641.          {
  642.             stringSourceChanged = false;
  643.             try
  644.             {
  645.                _source = document[_stringSource];
  646.             }
  647.             catch(e:Error)
  648.             {
  649.             }
  650.          }
  651.          if(sourceChanged)
  652.          {
  653.             sourceChanged = false;
  654.             dispatchEvent(new Event("sourceChanged"));
  655.          }
  656.          if(modeChanged)
  657.          {
  658.             modeChanged = false;
  659.             if(_source)
  660.             {
  661.                if(_mode == ProgressBarMode.EVENT)
  662.                {
  663.                   if(_source is IEventDispatcher)
  664.                   {
  665.                      addSourceListeners();
  666.                   }
  667.                   else
  668.                   {
  669.                      _source = null;
  670.                   }
  671.                }
  672.                else if(_source is IEventDispatcher)
  673.                {
  674.                   removeSourceListeners();
  675.                }
  676.             }
  677.             if(_mode == ProgressBarMode.POLLED)
  678.             {
  679.                pollTimer.addEventListener(TimerEvent.TIMER,updatePolledHandler,false,0,true);
  680.                pollTimer.start();
  681.             }
  682.             else if(stopPolledMode)
  683.             {
  684.                stopPolledMode = false;
  685.                pollTimer.removeEventListener(TimerEvent.TIMER,updatePolledHandler);
  686.                pollTimer.reset();
  687.             }
  688.             dispatchEvent(new Event("modeChanged"));
  689.          }
  690.       }
  691.       
  692.       override protected function resourcesChanged() : void
  693.       {
  694.          super.resourcesChanged();
  695.          label = labelOverride;
  696.       }
  697.       
  698.       public function set fontContext(param1:IFlexModuleFactory) : void
  699.       {
  700.          this.moduleFactory = param1;
  701.       }
  702.       
  703.       override public function set visible(param1:Boolean) : void
  704.       {
  705.          super.visible = param1;
  706.          visibleChanged = true;
  707.          invalidateDisplayList();
  708.       }
  709.       
  710.       public function set label(param1:String) : void
  711.       {
  712.          labelOverride = param1;
  713.          _label = param1 != null ? param1 : resourceManager.getString("controls","label");
  714.          invalidateDisplayList();
  715.          dispatchEvent(new Event("labelChanged"));
  716.       }
  717.       
  718.       override protected function childrenCreated() : void
  719.       {
  720.          super.childrenCreated();
  721.          trackSkinChanged = true;
  722.          barSkinChanged = true;
  723.          indeterminateSkinChanged = true;
  724.       }
  725.       
  726.       private function layoutContent(param1:Number, param2:Number) : void
  727.       {
  728.          mx_internal::_track.move(0,0);
  729.          mx_internal::_track.setActualSize(param1,param2);
  730.          mx_internal::_bar.move(0,0);
  731.          mx_internal::_determinateBar.move(0,0);
  732.          mx_internal::_indeterminateBar.setActualSize(param1 + getStyle("indeterminateMoveInterval"),param2);
  733.       }
  734.       
  735.       private function _setProgress(param1:Number, param2:Number) : void
  736.       {
  737.          var _loc3_:ProgressEvent = null;
  738.          if(enabled && !isNaN(param1) && !isNaN(param2))
  739.          {
  740.             _value = param1;
  741.             _maximum = param2;
  742.             dispatchEvent(new Event(Event.CHANGE));
  743.             _loc3_ = new ProgressEvent(ProgressEvent.PROGRESS);
  744.             _loc3_.bytesLoaded = param1;
  745.             _loc3_.bytesTotal = param2;
  746.             dispatchEvent(_loc3_);
  747.             if(_indeterminate)
  748.             {
  749.                startPlayingIndeterminate();
  750.             }
  751.             if(_value == _maximum && _value > 0)
  752.             {
  753.                if(_indeterminate)
  754.                {
  755.                   stopPlayingIndeterminate();
  756.                }
  757.                if(mode != ProgressBarMode.EVENT)
  758.                {
  759.                   dispatchEvent(new Event(Event.COMPLETE));
  760.                }
  761.             }
  762.             invalidateDisplayList();
  763.          }
  764.       }
  765.       
  766.       [Bindable("labelChanged")]
  767.       public function get label() : String
  768.       {
  769.          return _label;
  770.       }
  771.       
  772.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  773.       {
  774.          var _loc16_:Number = NaN;
  775.          var _loc17_:Graphics = null;
  776.          var _loc18_:Number = NaN;
  777.          super.updateDisplayList(param1,param2);
  778.          var _loc3_:Number = getStyle("horizontalGap");
  779.          var _loc4_:Number = getStyle("verticalGap");
  780.          var _loc5_:Number = getStyle("paddingLeft");
  781.          var _loc6_:Number = getStyle("paddingRight");
  782.          var _loc7_:Number = getStyle("paddingTop");
  783.          var _loc8_:Number = getStyle("paddingBottom");
  784.          var _loc9_:Number = _loc5_;
  785.          var _loc10_:Number = _loc7_;
  786.          var _loc11_:Number = getStyle("labelWidth");
  787.          var _loc12_:Number = getStyle("trackHeight");
  788.          _loc12_ = isNaN(_loc12_) ? Number(mx_internal::_track.measuredHeight) : _loc12_;
  789.          var _loc13_:TextLineMetrics = measureText(predictLabelText());
  790.          var _loc14_:Number = isNaN(_loc11_) ? _loc13_.width + UITextField.mx_internal::TEXT_WIDTH_PADDING : _loc11_;
  791.          var _loc15_:Number = _loc13_.height + UITextField.mx_internal::TEXT_HEIGHT_PADDING;
  792.          switch(labelPlacement)
  793.          {
  794.             case ProgressBarLabelPlacement.TOP:
  795.                mx_internal::_labelField.move(_loc9_,_loc10_);
  796.                mx_internal::_labelField.setActualSize(_loc14_,_loc15_);
  797.                mx_internal::_content.move(_loc9_,_loc10_ + _loc15_ + _loc4_);
  798.                layoutContent(param1 - _loc9_ - _loc6_,_loc12_);
  799.                break;
  800.             case ProgressBarLabelPlacement.RIGHT:
  801.                _loc16_ = param1 - _loc9_ - _loc6_ - _loc14_ - _loc3_;
  802.                mx_internal::_labelField.move(_loc9_ + _loc16_ + _loc3_,(param2 - _loc15_) / 2);
  803.                mx_internal::_labelField.setActualSize(_loc14_,_loc15_);
  804.                mx_internal::_content.move(_loc9_,_loc10_ + (_loc15_ - _loc12_) / 2);
  805.                layoutContent(_loc16_,_loc12_);
  806.                break;
  807.             case ProgressBarLabelPlacement.LEFT:
  808.                mx_internal::_labelField.move(_loc9_,_loc10_ + (param2 - _loc15_) / 2);
  809.                mx_internal::_labelField.setActualSize(_loc14_,_loc15_);
  810.                mx_internal::_content.move(_loc9_ + _loc14_ + _loc3_,_loc10_ + (_loc15_ - _loc12_) / 2);
  811.                layoutContent(param1 - _loc9_ - _loc14_ - _loc4_ - _loc6_,_loc12_);
  812.                break;
  813.             case ProgressBarLabelPlacement.CENTER:
  814.                mx_internal::_labelField.move((param1 - _loc14_) / 2,(param2 - _loc15_) / 2);
  815.                mx_internal::_labelField.setActualSize(_loc14_,_loc15_);
  816.                mx_internal::_content.move(_loc9_,_loc10_);
  817.                layoutContent(param1 - _loc6_,param2 - _loc8_);
  818.                break;
  819.             default:
  820.                mx_internal::_labelField.move(_loc9_,_loc10_ + _loc12_ + _loc4_);
  821.                mx_internal::_labelField.setActualSize(_loc14_,_loc15_);
  822.                mx_internal::_content.move(_loc9_,_loc10_);
  823.                layoutContent(param1 - _loc9_ - _loc6_,_loc12_);
  824.          }
  825.          if(mx_internal::_barMask)
  826.          {
  827.             mx_internal::_barMask.move(0,0);
  828.             if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  829.             {
  830.                mx_internal::_barMask.setActualSize(mx_internal::_track.width,mx_internal::_track.height);
  831.             }
  832.             else
  833.             {
  834.                _loc17_ = UIComponent(mx_internal::_barMask).graphics;
  835.                _loc17_.clear();
  836.                _loc17_.beginFill(16776960);
  837.                _loc17_.drawRect(1,1,mx_internal::_track.width - 2,mx_internal::_track.height - 2);
  838.                _loc17_.endFill();
  839.             }
  840.          }
  841.          mx_internal::_labelField.text = getFullLabelText();
  842.          mx_internal::_indeterminateBar.visible = _indeterminate;
  843.          if(indeterminateChanged || visibleChanged)
  844.          {
  845.             indeterminateChanged = false;
  846.             visibleChanged = false;
  847.             mx_internal::_indeterminateBar.visible = _indeterminate;
  848.             if(_indeterminate && _source == null && _mode == ProgressBarMode.EVENT && visible)
  849.             {
  850.                startPlayingIndeterminate();
  851.             }
  852.             else
  853.             {
  854.                stopPlayingIndeterminate();
  855.             }
  856.          }
  857.          if(_indeterminate)
  858.          {
  859.             mx_internal::_determinateBar.setActualSize(mx_internal::_track.width,mx_internal::_track.height);
  860.          }
  861.          else
  862.          {
  863.             _loc18_ = Math.max(0,mx_internal::_track.width * percentComplete / 100);
  864.             mx_internal::_determinateBar.setActualSize(_loc18_,mx_internal::_track.height);
  865.             mx_internal::_determinateBar.x = direction == ProgressBarDirection.RIGHT ? 0 : mx_internal::_track.width - _loc18_;
  866.          }
  867.       }
  868.       
  869.       public function set direction(param1:String) : void
  870.       {
  871.          if(param1 == ProgressBarDirection.LEFT || param1 == ProgressBarDirection.RIGHT)
  872.          {
  873.             _direction = param1;
  874.          }
  875.          invalidateDisplayList();
  876.          dispatchEvent(new Event("directionChanged"));
  877.       }
  878.    }
  879. }
  880.  
  881.